#ifndef SERVER_THREAD_H
#define SERVER_THREAD_H

#include <mutex>
#include <functional>
#include <condition_variable>
#include <thread>


// 注意如果 func 使用了外部的变量，一定要注意数据的竞争冒险
class ServerThread {
public:
    template <typename Callable>
    explicit ServerThread(Callable&& func) :
        exitFlag_(false), startTtsProcessing_(false),
        thread_([this, func_ = std::forward<Callable>(func)]() { funcWrapper(func_); }) 
        {}

    ~ServerThread() {
        destory();
    }

    // 禁止拷贝
    ServerThread(const ServerThread&) = delete;
    ServerThread& operator=(const ServerThread&) = delete;

    void destory(void) {
        if (is_destory) {
            return;
        }

        {
            std::lock_guard<std::mutex> lock(mtx_);
            exitFlag_ = true;
        }
        cv_.notify_one(); // 唤醒线程，让它可以检查 exitFlag_

        if (thread_.joinable()) {
            thread_.join(); // 等待线程退出，防止程序崩溃
        }

        is_destory = true;
    }

    // 触发线程执行任务
    void notify() {
        {
            std::lock_guard<std::mutex> lock(mtx_);
            startTtsProcessing_ = true;
        }
        cv_.notify_one();
    }

    // 线程退出检查点
    void manualExitPoint() {
        std::lock_guard<std::mutex> lock(mtx_);
        if (exitFlag_) exit(0);
    }

private:
    std::thread thread_;  // 线程对象
    bool exitFlag_;       // 线程退出标志
    bool startTtsProcessing_; // 任务开始标志

    // 内部的互斥锁 只保护 exitFlag_ 和 startTtsProcessing_
    std::mutex mtx_;
    std::condition_variable cv_;

    bool is_destory = false;

    template <typename Callable>
    void funcWrapper(Callable func) {
        while (!exitFlag_) {
            std::unique_lock<std::mutex> lock(mtx_);
            cv_.wait(lock, [this] { return exitFlag_ || startTtsProcessing_; });

            if (exitFlag_) break; // 线程退出

            startTtsProcessing_ = false;
            lock.unlock(); // 解锁，避免任务执行期间阻塞其他线程

            // 执行用户传入的任务
            func();
        }
    }
};

#endif // SERVER_THREAD_H
